home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d13 / pproject.arc / PROJECT.CLS < prev    next >
Encoding:
Text File  |  1990-06-07  |  7.0 KB  |  291 lines
  1. /* A Project is a network of Task and Milestone nodes to
  2.    manage CPM or PERT networks.  A project knows how to
  3.    calculate its critical path, keep track of costs etc.
  4.  
  5.    Since Project descends from Network, it inherits all of
  6.    Network's instance variables, e.g. start, end, name, desc.
  7. */!!
  8.  
  9. inherit(Network, #Project, #(cost      /* sum of all costs */
  10. resources /* used by tasks */
  11. autoCalc  /* boolean is recalc on? */
  12.  
  13. ), 2, nil)!!
  14.  
  15. now(ProjectClass)!!
  16.  
  17. now(Project)!!
  18.  
  19. /* Return only the tasks in the project. */
  20. Def  tasks(self)
  21. { 
  22.   ^extract(nodes(self),
  23.    {using(node) 
  24.     class(node) <> Milestone;
  25.    });
  26. }!!
  27.  
  28. /* Returns a collection of lines summarizing useful information. */
  29. Def  getInfoLines(self | tc)
  30. {
  31.   tc := new(OrderedCollection, 6);
  32.   add(tc, loadString(PW_PROJECT) + ": " + field(name, 8)+ "   " + desc);
  33.   add(tc, "");
  34.   add(tc, loadString(PW_PROJT1));
  35.   add(tc, "--------------------------------------------");
  36.   add(tc, loadString(PW_START)
  37.    + field(asString(getEarlyStart(self)), 8) + " "
  38.    + field(asString(getLateStart(self)), 8) + " "
  39.    + field(asString(getCost(self)), 6) + " "
  40.    + field(asString(getTime(self)), 6) + " " 
  41.    + field(asString(getSlack(self)), 4));
  42.   add(tc, loadString(PW_FINISH)
  43.    + field(asString(getEarlyFinish(self)), 8) + " "
  44.    + field(asString(getLateFinish(self)), 8));
  45.   ^tc;
  46.  }!!
  47.  
  48. /* Return the resource if the name exists in the
  49.    resources collection, otherwise return false and
  50.    display an error message. */
  51. Def  checkResExists(self, resName | res)
  52. {
  53.   if not(res := resExists(self, resName))
  54.     beep();
  55.     errorBox(loadString(PW_RESINVAL),
  56.              loadString(PW_RESOURCE) + " " + resName +
  57.              loadString(PW_NOTEXIST));
  58.   endif;
  59.   ^res;
  60. }!!
  61.  
  62. /* Return the resources collection. */
  63. Def  resources(self)
  64. { 
  65.   ^resources;
  66. }!!
  67.  
  68. /* Return the resource of the name resName if
  69.    it exists, otherwise return false. Use
  70.    checkResExists for error checking. */
  71. Def  resExists(self, resName | res)
  72. {
  73.   ^resName in resources;
  74. }!!
  75.  
  76. /* Parse a string of resNames and return a set of
  77.    resources.  If the resource doesn't exist, a new
  78.    one is created. */
  79. Def  parseResNames(self, resNames | names, res, aRes)
  80. {
  81.   names := words(resNames);
  82.   res := new(OrderedCollection, 6);
  83.   do(names,
  84.     {using(name) 
  85.      if not(aRes := resExists(self, name))  /* create it */
  86.        aRes := new(Resource);
  87.        setName(aRes, name);
  88.        if editInfo(aRes) == IDOK
  89.          add(resources, getName(aRes), aRes);
  90.          add(res, aRes);
  91.        endif;
  92.      else
  93.        add(res, aRes);
  94.      endif;
  95.   });
  96.   ^res;
  97. }!!
  98.  
  99. /* Return a sorted collection of activities in the project. 
  100.    Sort by earlyStart, time, name for unique order.  
  101.    This uses early binding and dot notation for speed. */
  102. Def  sortedActivities(self| sorted)
  103. {  
  104.   sorted := new(SortedCollection, 10);
  105.     
  106.   setCompareBlock(sorted, {using(a,b)
  107.                   if a.earlyStart = b.earlyStart
  108.                      if getTime(a) = getTime(b)
  109.                        a.name < b.name
  110.                      else
  111.                        getTime(a) < getTime(b)
  112.                      endif
  113.                   else
  114.                       a.earlyStart < b.earlyStart
  115.                  endif});
  116.  
  117.   do(nodeNames,
  118.      {using(aNode) 
  119.       add(sorted:SortedCollection, aNode);
  120.    });
  121.   ^sorted;
  122. }!!
  123.  
  124. /* Return the type of nodes that start and end should be.*/
  125. Def  nodeClass(self)
  126. {
  127.   ^Milestone;
  128. }!!
  129.  
  130. /* Return the current cost which is always up to date. */
  131. Def  getCost(self)
  132. {
  133.   ^cost;
  134. }!!
  135.  
  136. /* Get the user set late finish date. */
  137. Def  getUserLateFinish(self)
  138. { 
  139.   ^getUserLateFinish(end);
  140. }!!
  141.  
  142. /* Get the user set early start date. */
  143. Def  getUserEarlyStart(self)
  144. { 
  145.   ^getUserEarlyStart(start);
  146. } !!
  147.  
  148. /* Return a string to be used as a window caption. */
  149. Def  makeCaption(self)
  150. {
  151.   ^loadString(PW_PROJECT) + ": " + name;
  152. }!!
  153.  
  154. /* Set the values of a project. 
  155.    Values is an array of name, desc,
  156.    userEarlyStart, userLateFinish. 
  157.    This message is sent after editing. */
  158. Def  setValues(self, values)
  159. {
  160.   name := values[0];
  161.   desc := values[1];
  162.   if getEarlyStart(self) <> values[2]
  163.     setEarlyStart(self, values[2]);
  164.   endif;
  165.   if getLateFinish(self) <> values[3]
  166.     setLateFinish(self, values[3]);
  167.   endif;
  168. }!!
  169.  
  170. /* Display and edit the project information. 
  171.    The dialog should define methods run() and setEditItem().
  172. */
  173. Def  editInfo(self | dlg, retValue)
  174. {
  175.   showWaitCurs();
  176.   dlg := new(ProjDialog); 
  177.   setEditItem(dlg, self);
  178.   retValue := run(dlg, ThePort);
  179.   showOldCurs();
  180.   ^retValue;
  181. }!!
  182.  
  183. /* Project slack is defined as the slack at the end node.
  184.    This could be introduced if the user sets a lateFinish. */
  185. Def  getSlack(self)
  186. {
  187.   ^getSlack(end);
  188. }!!
  189.  
  190. /* Return the current cost which is always up to date. */
  191. Def  calcCost(self)
  192. {
  193.   ^cost;
  194. }!!
  195.  
  196. /* Update the cost based on a change to a Task. */
  197. Def  updateCost(self, change)
  198. { 
  199.   cost := cost + change;
  200. }!!
  201.  
  202. /* Do the backwards pass only starting from the end node.
  203.    The end node is always critical.
  204. */
  205. Def  recalc2(self)
  206. {  
  207.    recalc2(end);
  208.    end.critical := true;
  209. }!!
  210.  
  211. /* Turn automatic calculation on or off.
  212.    Force recalculation if turned on. */
  213. Def  setAutoCalc(self, mode)
  214. {
  215.   if (autoCalc := mode)   /* true or false */
  216.     recalc(self);    
  217.   endif;
  218. }!!
  219.  
  220. /* Recalculate the entire network. First invalidate all nodes
  221.    so that a full recalc will be forced.  Then do both the
  222.    forward and backwards recalc passes. The forward pass must
  223.    be entirely completed before doing the backwards pass. */
  224. Def  recalc(self)
  225. {
  226.    invalidate(start, new(Set,10)); /* clear all nodes */
  227.    recalc1(start, true);           /* force entire recalc */
  228.    recalc2(self);                  /* backwards pass */
  229. }!!
  230.  
  231. /* Get the project lateStart date. */
  232. Def  getLateStart(self)
  233. { 
  234.   ^getLateStart(start);
  235. }!!
  236.  
  237. /* Get the project earlyStart date. */
  238. Def  getEarlyStart(self)
  239. { 
  240.   ^getEarlyStart(start);
  241. } !! 
  242.  
  243. /* Get the project early finish date. */
  244. Def  getEarlyFinish(self)
  245. { 
  246.   ^getEarlyFinish(end);
  247. }!!
  248.  
  249. /* Get the project late finish date. */
  250. Def  getLateFinish(self)
  251. { 
  252.   ^getLateFinish(end);
  253. }!!
  254.  
  255. /* Return the status of autoCalc mode. */
  256. Def  autoCalc(self)
  257. {
  258.   ^autoCalc;
  259. }!!
  260.  
  261. /* The user can enter an early start date. */
  262. Def  setEarlyStart(self, aDate)
  263. { 
  264.   setEarlyStart(start,aDate);
  265. }!!
  266.  
  267. /* The user can enter a late finish date. */
  268. Def  setLateFinish(self, aDate)
  269. { 
  270.   setLateFinish(end,aDate);
  271. }!!
  272.  
  273. /* Calculate the project time. If negative (e.g. project
  274.    isn't fully hooked up yet) return 0. */
  275. Def  getTime(self)
  276. { ^max(0, getEarlyFinish(self) - getEarlyStart(self));
  277. }!!
  278.  
  279. /* Initialize a new Project. Uses ancestor init.
  280.    The nodeClass method determines the node type
  281.    for start and end. */
  282. Def  init(self)
  283. { 
  284.   init(self:Network);         /* use ancestor init */
  285.   cost := 0;
  286.   resources := new(Dictionary, 10);
  287.   setEarlyStart(start,        /* set default project start */
  288.     date(1,1,1988)); 
  289. }!!
  290.  
  291.